Pewarisan Variabel Konteks Asinkron JavaScript: Menguasai Rantai Propagasi Konteks

Pemrograman asinkron adalah landasan pengembangan JavaScript modern, terutama di lingkungan Node.js dan browser. Meskipun menawarkan manfaat kinerja yang signifikan, hal ini juga menimbulkan kerumitan, terutama saat mengelola konteks di seluruh operasi asinkron. Memastikan bahwa variabel dan data yang relevan dapat diakses di seluruh rantai eksekusi sangat penting untuk tugas-tugas seperti logging, autentikasi, pelacakan, dan penanganan permintaan. Di sinilah pemahaman dan penerapan pewarisan variabel konteks asinkron yang tepat menjadi esensial.

Memahami Tantangan Konteks Asinkron

Dalam JavaScript sinkron, mengakses variabel sangatlah mudah. Variabel yang dideklarasikan dalam lingkup induk tersedia di lingkup anak. Namun, operasi asinkron mengganggu model sederhana ini. Callback, promise, dan async/await memperkenalkan titik-titik di mana konteks eksekusi dapat bergeser, berpotensi kehilangan akses ke data penting. Perhatikan contoh berikut:

            function processRequest(req, res) {
  const userId = req.headers['user-id'];

  setTimeout(() => {
    // Masalah: Bagaimana cara kita mengakses userId di sini?
    console.log(`Processing request for user: ${userId}`); // userId mungkin tidak terdefinisi!
    res.send('Request processed');
  }, 1000);
}

            

              
                Copy
              
            
          

Dalam skenario yang disederhanakan ini, `userId` yang diperoleh dari header permintaan mungkin tidak dapat diakses secara andal di dalam callback `setTimeout`. Ini karena callback dieksekusi dalam iterasi event loop yang berbeda, yang berpotensi kehilangan konteks asli.

Memperkenalkan AsyncLocalStorage

AsyncLocalStorage, yang diperkenalkan di Node.js 14, menyediakan mekanisme untuk menyimpan dan mengambil data yang persisten di seluruh operasi asinkron. Ini bertindak seperti penyimpanan thread-local di bahasa lain, tetapi dirancang khusus untuk lingkungan JavaScript yang non-blocking dan event-driven.

Cara Kerja AsyncLocalStorage

AsyncLocalStorage memungkinkan Anda membuat instance penyimpanan yang mempertahankan datanya sepanjang masa hidup konteks eksekusi asinkron. Konteks ini secara otomatis disebarkan (propagated) melintasi panggilan `await`, promise, dan batasan asinkron lainnya, memastikan data yang disimpan tetap dapat diakses.

Penggunaan Dasar AsyncLocalStorage

            const { AsyncLocalStorage } = require('async_hooks');

const asyncLocalStorage = new AsyncLocalStorage();

function processRequest(req, res) {
  const userId = req.headers['user-id'];

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('userId', userId);

    setTimeout(() => {
      const currentUserId = asyncLocalStorage.getStore().get('userId');
      console.log(`Processing request for user: ${currentUserId}`);
      res.send('Request processed');
    }, 1000);
  });
}

            

              
                Copy
              
            
          

Dalam contoh yang direvisi ini, `AsyncLocalStorage.run()` membuat konteks eksekusi baru dengan penyimpanan awal (dalam kasus ini, sebuah `Map`). `userId` kemudian disimpan dalam konteks ini menggunakan `asyncLocalStorage.getStore().set()`. Di dalam callback `setTimeout`, `asyncLocalStorage.getStore().get()` mengambil `userId` dari konteks, memastikan ia tersedia bahkan setelah penundaan asinkron.

Konsep Kunci: Store dan Run

• Store: Store adalah wadah untuk data konteks Anda. Ini bisa berupa objek JavaScript apa pun, tetapi penggunaan `Map` atau objek sederhana adalah umum. Store bersifat unik untuk setiap konteks eksekusi asinkron.
• Run: Metode `run()` mengeksekusi fungsi dalam konteks instance AsyncLocalStorage. Metode ini menerima sebuah store dan fungsi callback. Segala sesuatu di dalam callback itu (dan operasi asinkron apa pun yang dipicunya) akan memiliki akses ke store tersebut.

AsyncResource: Menjembatani Kesenjangan dengan Operasi Asinkron Bawaan (Native)

Meskipun AsyncLocalStorage menyediakan mekanisme yang kuat untuk propagasi konteks dalam kode JavaScript, ia tidak secara otomatis meluas ke operasi asinkron bawaan (native) seperti akses sistem file atau permintaan jaringan. AsyncResource menjembatani kesenjangan ini dengan memungkinkan Anda secara eksplisit mengaitkan operasi-operasi ini dengan konteks AsyncLocalStorage saat ini.

Memahami AsyncResource

AsyncResource memungkinkan Anda membuat representasi dari operasi asinkron yang dapat dilacak oleh AsyncLocalStorage. Ini memastikan bahwa konteks AsyncLocalStorage disebarkan dengan benar ke callback atau promise yang terkait dengan operasi asinkron bawaan.

Menggunakan AsyncResource

            const { AsyncLocalStorage } = require('async_hooks');
const { AsyncResource } = require('async_hooks');
const fs = require('fs');

const asyncLocalStorage = new AsyncLocalStorage();

function processRequest(req, res) {
  const userId = req.headers['user-id'];

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('userId', userId);

    const resource = new AsyncResource('file-read-operation');

    fs.readFile('data.txt', 'utf8', (err, data) => {
      resource.runInAsyncScope(() => {
        const currentUserId = asyncLocalStorage.getStore().get('userId');
        console.log(`Processing data for user ${currentUserId}: ${data.length} bytes read`);
        res.send('Request processed');
        resource.emitDestroy();
      });
    });
  });
}

            

              
                Copy
              
            
          

Dalam contoh ini, `AsyncResource` digunakan untuk membungkus operasi `fs.readFile`. `resource.runInAsyncScope()` memastikan bahwa fungsi callback untuk `fs.readFile` dieksekusi dalam konteks AsyncLocalStorage, sehingga `userId` dapat diakses. Panggilan `resource.emitDestroy()` sangat penting untuk melepaskan sumber daya dan mencegah kebocoran memori setelah operasi asinkron selesai. Catatan: Kegagalan memanggil `emitDestroy()` dapat menyebabkan kebocoran sumber daya dan ketidakstabilan aplikasi.

Konsep Kunci: Manajemen Sumber Daya

• Pembuatan Sumber Daya: Buat instance `AsyncResource` sebelum memulai operasi asinkron. Konstruktornya menerima nama (digunakan untuk debugging) dan `triggerAsyncId` opsional.
• Propagasi Konteks: Gunakan `runInAsyncScope()` untuk mengeksekusi fungsi callback dalam konteks AsyncLocalStorage.
• Penghancuran Sumber Daya: Panggil `emitDestroy()` ketika operasi asinkron selesai untuk melepaskan sumber daya.

Membangun Rantai Propagasi Konteks

Kekuatan sejati dari AsyncLocalStorage dan AsyncResource terletak pada kemampuan mereka untuk menciptakan rantai propagasi konteks yang mencakup beberapa operasi asinkron dan panggilan fungsi. Ini memungkinkan Anda untuk mempertahankan konteks yang konsisten dan andal di seluruh aplikasi Anda.

Contoh: Alur Asinkron Berlapis

            const { AsyncLocalStorage } = require('async_hooks');
const { AsyncResource } = require('async_hooks');
const fs = require('fs');

const asyncLocalStorage = new AsyncLocalStorage();

async function fetchData() {
  return new Promise((resolve) => {
    const resource = new AsyncResource('data-fetch');
    fs.readFile('data.txt', 'utf8', (err, data) => {
      resource.runInAsyncScope(() => {
        resolve(data);
        resource.emitDestroy();
      });
    });
  });
}

async function processData(data) {
  const currentUserId = asyncLocalStorage.getStore().get('userId');
  console.log(`Processing data for user ${currentUserId}: ${data.length} bytes`);
  return `Processed by user ${currentUserId}: ${data.substring(0, 20)}...`;
}

async function sendResponse(processedData, res) {
  res.send(processedData);
}

function processRequest(req, res) {
  const userId = req.headers['user-id'];

  asyncLocalStorage.run(new Map(), async () => {
    asyncLocalStorage.getStore().set('userId', userId);

    const data = await fetchData();
    const processedData = await processData(data);
    await sendResponse(processedData, res);
  });
}

            

              
                Copy
              
            
          

Dalam contoh ini, `processRequest` memulai alur. Ia menggunakan `AsyncLocalStorage.run()` untuk membangun konteks awal dengan `userId`. `fetchData` membaca data dari file secara asinkron menggunakan `AsyncResource`. `processData` kemudian mengakses `userId` dari AsyncLocalStorage untuk memproses data. Akhirnya, `sendResponse` mengirimkan data yang telah diproses kembali ke klien. Kuncinya adalah `userId` tersedia di seluruh rantai asinkron ini karena propagasi konteks yang disediakan oleh AsyncLocalStorage.

Manfaat Rantai Propagasi Konteks

• Logging yang Disederhanakan: Akses informasi spesifik permintaan (mis., ID pengguna, ID permintaan) dalam logika logging Anda tanpa perlu meneruskannya secara eksplisit melalui beberapa panggilan fungsi. Ini membuat debugging dan audit lebih mudah.
• Konfigurasi Terpusat: Simpan pengaturan konfigurasi yang relevan dengan permintaan atau operasi tertentu dalam konteks AsyncLocalStorage. Ini memungkinkan Anda untuk menyesuaikan perilaku aplikasi secara dinamis berdasarkan konteks.
• Observabilitas yang Ditingkatkan: Integrasikan dengan sistem pelacakan untuk melacak alur eksekusi operasi asinkron dan mengidentifikasi hambatan kinerja.
• Keamanan yang Ditingkatkan: Kelola informasi terkait keamanan (mis., token autentikasi, peran otorisasi) dalam konteks, memastikan kontrol akses yang konsisten dan aman.

Praktik Terbaik Menggunakan AsyncLocalStorage dan AsyncResource

Meskipun AsyncLocalStorage dan AsyncResource adalah alat yang kuat, mereka harus digunakan dengan bijaksana untuk menghindari overhead kinerja dan potensi masalah.

Minimalkan Ukuran Store

Simpan hanya data yang benar-benar diperlukan untuk konteks asinkron. Hindari menyimpan objek besar atau data yang tidak perlu, karena ini dapat memengaruhi kinerja. Pertimbangkan untuk menggunakan struktur data ringan seperti Map atau objek JavaScript biasa.

Hindari Peralihan Konteks yang Berlebihan

Panggilan yang sering ke `AsyncLocalStorage.run()` dapat menimbulkan overhead kinerja. Kelompokkan operasi asinkron terkait dalam satu konteks jika memungkinkan. Hindari membuat konteks AsyncLocalStorage bersarang yang tidak perlu.

Tangani Kesalahan dengan Baik

Pastikan bahwa kesalahan dalam konteks AsyncLocalStorage ditangani dengan benar. Gunakan blok try-catch atau middleware penanganan kesalahan untuk mencegah pengecualian yang tidak tertangani mengganggu rantai propagasi konteks. Pertimbangkan untuk mencatat kesalahan dengan informasi spesifik konteks yang diambil dari store AsyncLocalStorage untuk debugging yang lebih mudah.

Gunakan AsyncResource secara Bertanggung Jawab

Selalu panggil `resource.emitDestroy()` setelah operasi asinkron selesai untuk melepaskan sumber daya. Kegagalan untuk melakukannya dapat menyebabkan kebocoran memori dan ketidakstabilan aplikasi. Gunakan AsyncResource hanya jika diperlukan untuk menjembatani kesenjangan antara kode JavaScript dan operasi asinkron bawaan. Untuk operasi asinkron yang murni JavaScript, AsyncLocalStorage saja seringkali sudah cukup.

Pertimbangkan Implikasi Kinerja

AsyncLocalStorage dan AsyncResource menimbulkan beberapa overhead kinerja. Meskipun umumnya dapat diterima untuk sebagian besar aplikasi, penting untuk menyadari dampak potensialnya, terutama dalam skenario yang kritis terhadap kinerja. Lakukan profil pada kode Anda dan ukur dampak kinerja penggunaan AsyncLocalStorage dan AsyncResource untuk memastikan bahwa itu memenuhi persyaratan aplikasi Anda.

Contoh: Menerapkan Logger Kustom dengan AsyncLocalStorage

            const { AsyncLocalStorage } = require('async_hooks');

const asyncLocalStorage = new AsyncLocalStorage();

const logger = {
  log: (message) => {
    const requestId = asyncLocalStorage.getStore()?.get('requestId') || 'N/A';
    console.log(`[${requestId}] ${message}`);
  },
  error: (message) => {
    const requestId = asyncLocalStorage.getStore()?.get('requestId') || 'N/A';
    console.error(`[${requestId}] ERROR: ${message}`);
  },
};

function processRequest(req, res, next) {
  const requestId = Math.random().toString(36).substring(7); // Buat ID permintaan yang unik

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('requestId', requestId);
    logger.log('Request received');
    next(); // Berikan kontrol ke middleware berikutnya
  });
}

// Contoh Penggunaan (dalam aplikasi Express.js)
// app.use(processRequest);
// app.get('/data', (req, res) => {
//   logger.log('Fetching data...');
//   res.send('Data retrieved successfully');
// });

// Jika terjadi kesalahan:
// try {
//   // beberapa kode yang mungkin menimbulkan kesalahan
// } catch (error) {
//   logger.error(`An error occurred: ${error.message}`);
//   // ...
// }

            

              
                Copy
              
            
          

Contoh ini menunjukkan bagaimana AsyncLocalStorage dapat digunakan untuk mengimplementasikan logger kustom yang secara otomatis menyertakan ID permintaan di setiap pesan log. Ini menghilangkan kebutuhan untuk secara eksplisit meneruskan ID permintaan ke fungsi logging, membuat kode lebih bersih dan lebih mudah dipelihara.

Alternatif untuk AsyncLocalStorage

Meskipun AsyncLocalStorage memberikan solusi yang kuat untuk propagasi konteks, ada pendekatan lain. Tergantung pada kebutuhan spesifik aplikasi Anda, alternatif-alternatif ini mungkin lebih cocok.

Penerusan Konteks secara Eksplisit

Pendekatan paling sederhana adalah dengan secara eksplisit meneruskan data konteks sebagai argumen ke panggilan fungsi. Meskipun mudah, ini bisa menjadi rumit dan rawan kesalahan, terutama dalam alur asinkron yang kompleks. Ini juga mengikat erat fungsi dengan data konteks, membuat kode kurang modular dan dapat digunakan kembali.

cls-hooked (Modul Komunitas)

`cls-hooked` adalah modul komunitas populer yang menyediakan fungsionalitas serupa dengan AsyncLocalStorage, tetapi mengandalkan monkey-patching pada API Node.js. Meskipun mungkin lebih mudah digunakan dalam beberapa kasus, umumnya disarankan untuk menggunakan AsyncLocalStorage bawaan jika memungkinkan, karena lebih berkinerja dan lebih kecil kemungkinannya menimbulkan masalah kompatibilitas.

Pustaka Propagasi Konteks

Beberapa pustaka menyediakan abstraksi tingkat lebih tinggi untuk propagasi konteks. Pustaka-pustaka ini sering menawarkan fitur seperti pelacakan otomatis, integrasi logging, dan dukungan untuk berbagai jenis konteks. Contohnya termasuk pustaka yang dirancang untuk kerangka kerja atau platform observabilitas tertentu.

Kesimpulan

JavaScript AsyncLocalStorage dan AsyncResource menyediakan mekanisme yang kuat untuk mengelola konteks di seluruh operasi asinkron. Dengan memahami konsep store, run, dan manajemen sumber daya, Anda dapat membangun aplikasi asinkron yang kuat, mudah dipelihara, dan dapat diamati. Meskipun ada alternatif lain, AsyncLocalStorage menawarkan solusi bawaan dan berkinerja untuk sebagian besar kasus penggunaan. Dengan mengikuti praktik terbaik dan mempertimbangkan implikasi kinerja dengan cermat, Anda dapat memanfaatkan AsyncLocalStorage untuk menyederhanakan kode Anda dan meningkatkan kualitas keseluruhan aplikasi asinkron Anda. Ini menghasilkan kode yang tidak hanya lebih mudah untuk di-debug, tetapi juga lebih aman, andal, dan dapat diskalakan di lingkungan asinkron yang kompleks saat ini. Jangan lupakan langkah krusial `resource.emitDestroy()` saat menggunakan `AsyncResource` untuk mencegah potensi kebocoran memori. Manfaatkan alat-alat ini untuk menaklukkan kerumitan konteks asinkron dan membangun aplikasi JavaScript yang benar-benar luar biasa.